var t = require('./typeof');
function r() {
  (module.exports = r =
    function () {
      return e;
    }),
    (module.exports.__esModule = !0),
    (module.exports.default = module.exports);
  var e = {},
    n = Object.prototype,
    o = n.hasOwnProperty,
    i =
      Object.defineProperty ||
      function (t, r, e) {
        t[r] = e.value;
      },
    a = 'function' == typeof Symbol ? Symbol : {},
    c = a.iterator || '@@iterator',
    u = a.asyncIterator || '@@asyncIterator',
    l = a.toStringTag || '@@toStringTag';
  function h(t, r, e) {
    return (
      Object.defineProperty(t, r, {
        value: e,
        enumerable: !0,
        configurable: !0,
        writable: !0,
      }),
      t[r]
    );
  }
  try {
    h({}, '');
  } catch (t) {
    h = function (t, r, e) {
      return (t[r] = e);
    };
  }
  function f(t, r, e, n) {
    var o = r && r.prototype instanceof d ? r : d,
      a = Object.create(o.prototype),
      c = new k(n || []);
    return i(a, '_invoke', { value: E(t, e, c) }), a;
  }
  function s(t, r, e) {
    try {
      return { type: 'normal', arg: t.call(r, e) };
    } catch (t) {
      return { type: 'throw', arg: t };
    }
  }
  e.wrap = f;
  var p = {};
  function d() {}
  function v() {}
  function y() {}
  var g = {};
  h(g, c, function () {
    return this;
  });
  var m = Object.getPrototypeOf,
    w = m && m(m(G([])));
  w && w !== n && o.call(w, c) && (g = w);
  var x = (y.prototype = d.prototype = Object.create(g));
  function L(t) {
    ['next', 'throw', 'return'].forEach(function (r) {
      h(t, r, function (t) {
        return this._invoke(r, t);
      });
    });
  }
  function b(r, e) {
    function n(i, a, c, u) {
      var l = s(r[i], r, a);
      if ('throw' !== l.type) {
        var h = l.arg,
          f = h.value;
        return f && 'object' == t(f) && o.call(f, '__await')
          ? e.resolve(f.__await).then(
              function (t) {
                n('next', t, c, u);
              },
              function (t) {
                n('throw', t, c, u);
              },
            )
          : e.resolve(f).then(
              function (t) {
                (h.value = t), c(h);
              },
              function (t) {
                return n('throw', t, c, u);
              },
            );
      }
      u(l.arg);
    }
    var a;
    i(this, '_invoke', {
      value: function (t, r) {
        function o() {
          return new e(function (e, o) {
            n(t, r, e, o);
          });
        }
        return (a = a ? a.then(o, o) : o());
      },
    });
  }
  function E(t, r, e) {
    var n = 'suspendedStart';
    return function (o, i) {
      if ('executing' === n) throw new Error('Generator is already running');
      if ('completed' === n) {
        if ('throw' === o) throw i;
        return N();
      }
      for (e.method = o, e.arg = i; ; ) {
        var a = e.delegate;
        if (a) {
          var c = _(a, e);
          if (c) {
            if (c === p) continue;
            return c;
          }
        }
        if ('next' === e.method) e.sent = e._sent = e.arg;
        else if ('throw' === e.method) {
          if ('suspendedStart' === n) throw ((n = 'completed'), e.arg);
          e.dispatchException(e.arg);
        } else 'return' === e.method && e.abrupt('return', e.arg);
        n = 'executing';
        var u = s(t, r, e);
        if ('normal' === u.type) {
          if (((n = e.done ? 'completed' : 'suspendedYield'), u.arg === p))
            continue;
          return { value: u.arg, done: e.done };
        }
        'throw' === u.type &&
          ((n = 'completed'), (e.method = 'throw'), (e.arg = u.arg));
      }
    };
  }
  function _(t, r) {
    var e = r.method,
      n = t.iterator[e];
    if (void 0 === n)
      return (
        (r.delegate = null),
        ('throw' === e &&
          t.iterator.return &&
          ((r.method = 'return'),
          (r.arg = void 0),
          _(t, r),
          'throw' === r.method)) ||
          ('return' !== e &&
            ((r.method = 'throw'),
            (r.arg = new TypeError(
              "The iterator does not provide a '" + e + "' method",
            )))),
        p
      );
    var o = s(n, t.iterator, r.arg);
    if ('throw' === o.type)
      return (r.method = 'throw'), (r.arg = o.arg), (r.delegate = null), p;
    var i = o.arg;
    return i
      ? i.done
        ? ((r[t.resultName] = i.value),
          (r.next = t.nextLoc),
          'return' !== r.method && ((r.method = 'next'), (r.arg = void 0)),
          (r.delegate = null),
          p)
        : i
      : ((r.method = 'throw'),
        (r.arg = new TypeError('iterator result is not an object')),
        (r.delegate = null),
        p);
  }
  function O(t) {
    var r = { tryLoc: t[0] };
    1 in t && (r.catchLoc = t[1]),
      2 in t && ((r.finallyLoc = t[2]), (r.afterLoc = t[3])),
      this.tryEntries.push(r);
  }
  function j(t) {
    var r = t.completion || {};
    (r.type = 'normal'), delete r.arg, (t.completion = r);
  }
  function k(t) {
    (this.tryEntries = [{ tryLoc: 'root' }]),
      t.forEach(O, this),
      this.reset(!0);
  }
  function G(t) {
    if (t) {
      var r = t[c];
      if (r) return r.call(t);
      if ('function' == typeof t.next) return t;
      if (!isNaN(t.length)) {
        var e = -1,
          n = function r() {
            for (; ++e < t.length; )
              if (o.call(t, e)) return (r.value = t[e]), (r.done = !1), r;
            return (r.value = void 0), (r.done = !0), r;
          };
        return (n.next = n);
      }
    }
    return { next: N };
  }
  function N() {
    return { value: void 0, done: !0 };
  }
  return (
    (v.prototype = y),
    i(x, 'constructor', { value: y, configurable: !0 }),
    i(y, 'constructor', { value: v, configurable: !0 }),
    (v.displayName = h(y, l, 'GeneratorFunction')),
    (e.isGeneratorFunction = function (t) {
      var r = 'function' == typeof t && t.constructor;
      return (
        !!r && (r === v || 'GeneratorFunction' === (r.displayName || r.name))
      );
    }),
    (e.mark = function (t) {
      return (
        Object.setPrototypeOf
          ? Object.setPrototypeOf(t, y)
          : ((t.__proto__ = y), h(t, l, 'GeneratorFunction')),
        (t.prototype = Object.create(x)),
        t
      );
    }),
    (e.awrap = function (t) {
      return { __await: t };
    }),
    L(b.prototype),
    h(b.prototype, u, function () {
      return this;
    }),
    (e.AsyncIterator = b),
    (e.async = function (t, r, n, o, i) {
      void 0 === i && (i = Promise);
      var a = new b(f(t, r, n, o), i);
      return e.isGeneratorFunction(r)
        ? a
        : a.next().then(function (t) {
            return t.done ? t.value : a.next();
          });
    }),
    L(x),
    h(x, l, 'Generator'),
    h(x, c, function () {
      return this;
    }),
    h(x, 'toString', function () {
      return '[object Generator]';
    }),
    (e.keys = function (t) {
      var r = Object(t),
        e = [];
      for (var n in r) e.push(n);
      return (
        e.reverse(),
        function t() {
          for (; e.length; ) {
            var n = e.pop();
            if (n in r) return (t.value = n), (t.done = !1), t;
          }
          return (t.done = !0), t;
        }
      );
    }),
    (e.values = G),
    (k.prototype = {
      constructor: k,
      reset: function (t) {
        if (
          ((this.prev = 0),
          (this.next = 0),
          (this.sent = this._sent = void 0),
          (this.done = !1),
          (this.delegate = null),
          (this.method = 'next'),
          (this.arg = void 0),
          this.tryEntries.forEach(j),
          !t)
        )
          for (var r in this)
            't' === r.charAt(0) &&
              o.call(this, r) &&
              !isNaN(+r.slice(1)) &&
              (this[r] = void 0);
      },
      stop: function () {
        this.done = !0;
        var t = this.tryEntries[0].completion;
        if ('throw' === t.type) throw t.arg;
        return this.rval;
      },
      dispatchException: function (t) {
        if (this.done) throw t;
        var r = this;
        function e(e, n) {
          return (
            (a.type = 'throw'),
            (a.arg = t),
            (r.next = e),
            n && ((r.method = 'next'), (r.arg = void 0)),
            !!n
          );
        }
        for (var n = this.tryEntries.length - 1; n >= 0; --n) {
          var i = this.tryEntries[n],
            a = i.completion;
          if ('root' === i.tryLoc) return e('end');
          if (i.tryLoc <= this.prev) {
            var c = o.call(i, 'catchLoc'),
              u = o.call(i, 'finallyLoc');
            if (c && u) {
              if (this.prev < i.catchLoc) return e(i.catchLoc, !0);
              if (this.prev < i.finallyLoc) return e(i.finallyLoc);
            } else if (c) {
              if (this.prev < i.catchLoc) return e(i.catchLoc, !0);
            } else {
              if (!u) throw new Error('try statement without catch or finally');
              if (this.prev < i.finallyLoc) return e(i.finallyLoc);
            }
          }
        }
      },
      abrupt: function (t, r) {
        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
          var n = this.tryEntries[e];
          if (
            n.tryLoc <= this.prev &&
            o.call(n, 'finallyLoc') &&
            this.prev < n.finallyLoc
          ) {
            var i = n;
            break;
          }
        }
        i &&
          ('break' === t || 'continue' === t) &&
          i.tryLoc <= r &&
          r <= i.finallyLoc &&
          (i = null);
        var a = i ? i.completion : {};
        return (
          (a.type = t),
          (a.arg = r),
          i
            ? ((this.method = 'next'), (this.next = i.finallyLoc), p)
            : this.complete(a)
        );
      },
      complete: function (t, r) {
        if ('throw' === t.type) throw t.arg;
        return (
          'break' === t.type || 'continue' === t.type
            ? (this.next = t.arg)
            : 'return' === t.type
              ? ((this.rval = this.arg = t.arg),
                (this.method = 'return'),
                (this.next = 'end'))
              : 'normal' === t.type && r && (this.next = r),
          p
        );
      },
      finish: function (t) {
        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
          var e = this.tryEntries[r];
          if (e.finallyLoc === t)
            return this.complete(e.completion, e.afterLoc), j(e), p;
        }
      },
      catch: function (t) {
        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
          var e = this.tryEntries[r];
          if (e.tryLoc === t) {
            var n = e.completion;
            if ('throw' === n.type) {
              var o = n.arg;
              j(e);
            }
            return o;
          }
        }
        throw new Error('illegal catch attempt');
      },
      delegateYield: function (t, r, e) {
        return (
          (this.delegate = { iterator: G(t), resultName: r, nextLoc: e }),
          'next' === this.method && (this.arg = void 0),
          p
        );
      },
    }),
    e
  );
}
(module.exports = r),
  (module.exports.__esModule = !0),
  (module.exports.default = module.exports);
